Code Generation with the Model Transformation of Visual Behavior Models

There exist numerous techniques to define the abstract and the concrete syntax of metamodeled languages. However, only a few solutions are available to describe the dynamic behavior (animation) of visual languages. The aim of our research is to provide visual modeling techniques to define the dynamic behavior of the languages. Previously, we have created languages to describe animation. In this paper, we describe how these models can be processed by model transformation techniques. We elaborate the main steps of the transformation and show the details as well. We use graph rewriting-based model transformation, therefore we provide a highly generic solution which can be easily modified, and analyzed with the techniques borrowed from the field of graph rewriting. The termination analysis for the presented method is also provided

Active Model Patterns with Interactive Model Transformation

With the proliferation of domain-specific languages, the generalization of OO patterns is a natural demand. Concepts and tools supporting pattern specification and execution for arbitrary domain-specific languages facilitate to meet these requirements. Our previous work introduced the Active Model Pattern Infrastructure and possible realizations for its static aspect. In this paper, we contribute a realization for the operational aspect of the framework. We propose graph rewriting-based interactive model transformation to describe and automate often recurring operational patterns in domain-specific modeling. We have extended a general transformation system with localized application of the rules and facilitate run-time customization possibilities for the domain engineer to influence the execution of the operations. We can specialize this approach to provide an implementation of the static aspect as well. We have realized our solution in the Visual Modeling and Transformation System

An Incremental OCL Compiler for Modeling Environments

In software engineering, reliability and development time are two of the most important aspects, therefore, modeling environments, which aide both, are widely used during software development. UML and OCL became industry standards, and are supported by many CASE tools. OCL code checking, which has to be performed by these tools, has a specialty, as not all of the information necessary for compilation is available from the code, the related model contains the types, navigations and attributes. The build time of OCL code fragments is increased if the development tool supports distributed modeling, because in this case, model element checking has to be performed in a model repository that cannot be held in memory. In this paper, we introduce a method that enables incremental OCL code building and therefore reduces the development time. Incremental builds require higher complexity than simple builds, thus balancing between the two methods is also considered

A Model Transformation for Automated Concrete Syntax Definitions of Metamodeled Visual Languages

Metamodeling techniques are popular in describing the rules of special domains, but these techniques do not support defining presentation for these domains , namely the concrete syntax. The aim of our research is to provide a method to create the concrete syntax for metamodeling systems in a flexible, efficient way. Several domain-specific languages have been created that support defining the concrete syntax, i.e. the visualization. The main concern of this paper is to present a model transformation method that processes our presentation definitions and transforms them automatically into source code. The source code implements a plug-in capable of editing the models. A termination analysis for the presented method is also provided

Towards a classification to facilitate the design of domain-specific visual languages

Domain-specific visual languages (DSVLs) are specialized modeling languages that allow the effective management of the behavior and the structure of software programs and systems in a specific domain. Each DSVL has its specific structural and graphical characteristics depending on the problem domain. In the recent decade, a wide range of tools and methodologies have been introduced to support the design of DSVLs for various domains, therefore it can be a challenging task to choose the most appropriate techniques for the design process. Our research aims to present a classification to guide the identification of the most relevant and appropriate methodologies in the given scenario. The classification is capable enough to provide a clear and precise understanding of the main aspects that can facilitate the design of DSVLs

Towards a classification-based systematic approach to facilitate the design of domain-specific visual languages

Domain-specific visual languages (DSVLs) are specialized modeling languages that allow the effective management of the behavior and the structure of software programs and systems in a specific domain. Each DSVL has its specific structural and graphical characteristics depending on the problem domain. In the recent decade, a wide range of tools and methodologies have been introduced to support the design of DSVLs for various domains, therefore it can be a challenging task to choose the most appropriate technique for the design process. Our research aims to present a classification-based systematic approach to guide the identification of the most relevant and appropriate methodologies in the given scenario. The approach can be capable enough to provide a clear and precise understanding of the main aspects that can facilitate the design of DSVLs

Systematic Transformation Development

Despite the pivotal significance of transformations for model-driven approaches, there have not been any attempts to explicitly model transformation languages yet although a number of benefits are to be gained. First, transformation developers may change the design of their transformation languages by modeling, rather than programming. Second, they may use environments to create transformations that are customized with respect to the input and output languages involved. In this paper, we use a running example to identify, discuss, and demonstrate some of the above advantages. In particular, we explore and suggest ways to systematically support developers in creating transformation languages by means of semi-automated metamodeling